// #include "../source/Socket.hpp"

// int main()
// {
// 	// 创建客户端套接字
// 	Socket client;
// 	if (!client.CreateTcpClient("127.0.0.1", 8080))
// 	{
// 		std::cerr << "连接服务器失败" << std::endl;
// 		return 1;
// 	}

// 	std::cout << "已连接到服务器" << std::endl;
// 	while (true)
// 	{
// 		// 固定消息
// 		const char *message = "Hello, TCP Echo Server!";

// 		// 发送消息
// 		if (client.Send(message, strlen(message)) <= 0)
// 		{
// 			std::cerr << "发送失败" << std::endl;
// 			return 1;
// 		}

// 		std::cout << "已发送消息: " << message << std::endl;

// 		// 接收回显
// 		char buffer[1024];
// 		ssize_t n = client.Recv(buffer, sizeof(buffer) - 1);
// 		if (n <= 0)
// 		{
// 			std::cerr << "接收失败" << std::endl;
// 			return 1;
// 		}

// 		buffer[n] = '\0'; // 确保字符串结束
// 		std::cout << "收到回显: " << buffer << std::endl;
// 	}

// 	client.Close();
// 	return 0;
// }

// int main()
// {
// 	Socket s;
// 	s.CreateTcpClient("127.0.0.1", 8080);
// 	int n = 5;
// 	while (n)
// 	{
// 		sleep(1);
// 	    std::string str = "拜拜";
// 		s.Send(str.c_str(), str.size());
// 		char buff[1024] = {0};
// 		s.Recv(buff, 1023);
// 		INF_LOG("%s",buff);
// 		sleep(3);
// 	}
// 	while(1) sleep(1);
// 	s.Close();
// 	return 0;
// }

// // 长链接短链接测试
// #include "../source/TcpServer.hpp"

// int main()
// {
//     Socket cli_sock;
//     cli_sock.CreateTcpClient("127.0.0.1", 8080);
//     std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
//     while(1) {
//         assert(cli_sock.Send(req.c_str(), req.size()) != -1);
//         char buf[1024] = {0};
//         assert(cli_sock.Recv(buf, 1023));
//         INF_LOG("[%s]", buf);
//         sleep(3);
//     }
//     cli_sock.Close();
//     return 0;
// }

// // 超时链接关闭测试
// #include "../source/TcpServer.hpp"

// int main()
// {
//     Socket cli_sock;
//     cli_sock.CreateTcpClient("127.0.0.1", 8080);
//     std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
//     while(1) {
//         assert(cli_sock.Send(req.c_str(), req.size()) != -1);
//         char buf[1024] = {0};
//         assert(cli_sock.Recv(buf, 1023));
//         INF_LOG("[%s]", buf);
//         sleep(15);
//     }
//     cli_sock.Close();
//     return 0;
// }

/*给服务器发送一个数据，告诉服务器要发送1024字节的数据，但是实际发送的数据不足1024，查看服务器处理结果*/
/*
    1. 如果数据只发送一次，服务器将得不到完整请求，就不会进行业务处理，客户端也就得不到响应，最终超时关闭连接
    2. 连着给服务器发送了多次 小的请求，  服务器会将后边的请求当作前边请求的正文进行处理，而后便处理的时候有可能就会因为处理错误而关闭连接
*/
// #include "../source/TcpServer.hpp"

// int main()
// {
//     Socket cli_sock;
//     cli_sock.CreateTcpClient("127.0.0.1", 8080);
//     std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 100\r\n\r\nbitejiuyeke";
//     while(1) {
//         assert(cli_sock.Send(req.c_str(), req.size()) != -1);
//         assert(cli_sock.Send(req.c_str(), req.size()) != -1);
//         assert(cli_sock.Send(req.c_str(), req.size()) != -1);
//         assert(cli_sock.Send(req.c_str(), req.size()) != -1);
//         char buf[1024] = {0};
//         assert(cli_sock.Recv(buf, 1023));
//         INF_LOG("[%s]", buf);
//         sleep(15);
//     }
//     cli_sock.Close();
//     return 0;
// }

/* 业务处理超时，查看服务器的处理情况
    当服务器达到了一个性能瓶颈，在一次业务处理中花费了太长的时间（超过了服务器设置的非活跃超时时间）
     1. 在一次业务处理中耗费太长时间，导致其他的连接也被连累超时，其他的连接有可能会被拖累超时释放
     假设现在  12345描述符就绪了， 在处理1的时候花费了30s处理完，超时了，导致2345描述符因为长时间没有刷新活跃度
       1. 如果接下来的2345描述符都是通信连接描述符，如果都就绪了，则并不影响，因为接下来就会进行处理并刷新活跃度
       2. 如果接下来的2号描述符是定时器事件描述符，定时器触发超时，执行定时任务，就会将345描述符给释放掉
          这时候一旦345描述符对应的连接被释放，接下来在处理345事件的时候就会导致程序崩溃（内存访问错误）
          因此这时候，在本次事件处理中，并不能直接对连接进行释放，而应该将释放操作压入到任务池中，
          等到事件处理完了执行任务池中的任务的时候，再去释放
*/

// #include "../source/TcpServer.hpp"

// int main()
// {
//     for (int i = 0; i < 10; i++)
//     {
//         pid_t n = fork();
//         if (n < 0)
//         {
//             INF_LOG("fork error");
//         }
//         else if(n == 0)
//         {
//             Socket cli_sock;
//             cli_sock.CreateTcpClient("127.0.0.1", 8080);
//             std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
//             while (1)
//             {
//                 assert(cli_sock.Send(req.c_str(), req.size()) != -1);
//                 char buf[1024] = {0};
//                 assert(cli_sock.Recv(buf, 1023));
//                 INF_LOG("[%s]", buf);
//             }
//             cli_sock.Close();
//         }
//     }
//     while(1)
//     {
//         sleep(1);
//     }
//     return 0;
// }

/*一次性给服务器发送多条数据，然后查看服务器的处理结果*/
/*每一条请求都应该得到正常处理*/

// #include "../source/TcpServer.hpp"

// int main()
// {
//     Socket cli_sock;
//     cli_sock.CreateTcpClient("127.0.0.1", 8080);
//     std::string req = "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
//     // req += "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
//     // req += "GET /hello HTTP/1.1\r\nConnection: keep-alive\r\nContent-Length: 0\r\n\r\n";
//     while(1) {
//         assert(cli_sock.Send(req.c_str(), req.size()) != -1);
//         char buf[1024] = {0};
//         assert(cli_sock.Recv(buf, 1023));
//         INF_LOG("[%s]", buf);
//         sleep(15);
//     }
//     cli_sock.Close();
//     return 0;
// }

#include "../source/HttpServer.hpp"

int main()
{
    Socket cli_sock;
    cli_sock.CreateTcpClient("127.0.0.1", 8080);
    std::string req = "PUT /1234.txt HTTP/1.1\r\nConnection: keep-alive\r\n";
    std::string body;
    Util::ReadFile("./hello.txt", &body);
    req += "Content-Length: " + std::to_string(body.size()) + "\r\n\r\n";
    assert(cli_sock.Send(req.c_str(), req.size()) != -1);
    assert(cli_sock.Send(body.c_str(), body.size()) != -1);
    char buf[1024] = {0};
    assert(cli_sock.Recv(buf, 1023));
    INF_LOG("[%s]", buf);
    sleep(3);
    cli_sock.Close();
    return 0;
}

